<?xml version="1.0"?>
<doc>
    <assembly>
        <name>OpenMI.Standard</name>
    </assembly>
    <members>
        <member name="T:OpenMI.Standard.IVector">
            <summary>
            Vector interface
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IVector.XComponent">
            <summary>
            Vector component in X-direction
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IVector.YComponent">
            <summary>
            Vector component in Y-direction
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IVector.ZComponent">
            <summary>
            Vector component in Z-direction
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IVectorSet">
            <summary>
            VectorSet interface
            (Array of vectors for a certain quantity on a certain elementset).
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IValueSet">
            <summary>
            ValueSet interface
            (Base for VectorSet and ScalarSet)
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IValueSet.IsValid(System.Int32)">
            <summary>
            Is a value valid or missing/deleted?
            </summary>
            <param name="elementIndex">The element index.</param>
            <returns>True if the value is valid.</returns>
        </member>
        <member name="P:OpenMI.Standard.IValueSet.Count">
            <summary>
            Number of elements in the set
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IVectorSet.GetVector(System.Int32)">
            <summary>
            Vector for one of the elements in the set
            </summary>
            <param name="elementIndex">index in the vector set.</param>
            <returns>vector.</returns>
        </member>
        <member name="T:OpenMI.Standard.ITime">
            <summary>
            Time interface
            ('Abstract' interface, base for TimeStamp and TimeSpan)
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IManageState">
            <summary>
            Manage State Interface. (To be implemented optionally, in addition to
            the linkable component interface.)
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IManageState.KeepCurrentState">
            <summary>
            Store the linkable component's current State
            </summary>
            <returns>State identifier.</returns>
        </member>
        <member name="M:OpenMI.Standard.IManageState.RestoreState(System.String)">
            <summary>
            Restores the state identified by the parameter stateID. If the state identifier identified by
            stateID is not known by the linkable component an exception should be trown.
            </summary>
            <param name="stateID">State identifier.</param>
        </member>
        <member name="M:OpenMI.Standard.IManageState.ClearState(System.String)">
            <summary>
            Clears a state from the linkable component's memory. If the state identifier identified by
            stateID is not known by the linkable component an exception should be trown.
            </summary>
            <param name="stateID">State identifier.</param>
        </member>
        <member name="T:OpenMI.Standard.IInputExchangeItem">
            <summary>
            <para>An IInputExchangeItem describes an input item that can be accepted by a LinkableComponent.
            The item describes a combination of quantity and elementSet that can be accepted.</para>
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IExchangeItem">
            <summary>
            ExchangeItem interface
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IExchangeItem.Quantity">
            <summary>
            The Quantity
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IExchangeItem.ElementSet">
            <summary>
            The ElementSet
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IArgument">
            <summary>
            The IArgument interface defines a key – value pair. If the property ReadOnly is
            false the value is editable otherwise it is read-only. 
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IArgument.Key">
            <summary>
            The key (string) in key-value pair.
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IArgument.Value">
            <summary>
            <para>The value (double) in key-value pair.</para> 
            
            <para>If the ReadOnly property is true and the property is attempted to be changed 
            from outside an exception must be thrown.</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IArgument.ReadOnly">
            <summary>
            Defines whether the Values property may be edited from outside. 
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IArgument.Description">
            <summary>
            Description of the key-value pair.
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IPublisher">
            <summary>
            Publisher interface
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IPublisher.Subscribe(OpenMI.Standard.IListener,OpenMI.Standard.EventType)">
            <summary>
            Subscribes a listener
            </summary>
            <param name="listener">The listener.</param>
            <param name="eventType">The event type.</param>
        </member>
        <member name="M:OpenMI.Standard.IPublisher.UnSubscribe(OpenMI.Standard.IListener,OpenMI.Standard.EventType)">
            <summary>
            Unsubscribes a listener
            </summary>
            <param name="listener">The listener.</param>
            <param name="eventType">The event type.</param>
        </member>
        <member name="M:OpenMI.Standard.IPublisher.SendEvent(OpenMI.Standard.IEvent)">
            <summary>
            Sends an event to all subscribed listeners
            </summary>
            <param name="Event">The event.</param>
        </member>
        <member name="M:OpenMI.Standard.IPublisher.GetPublishedEventTypeCount">
            <summary>
            Get number of published event types
            </summary>
            <returns>Number of provided event types.</returns>
        </member>
        <member name="M:OpenMI.Standard.IPublisher.GetPublishedEventType(System.Int32)">
            <summary>
            Get provided event type with index providedEventTypeIndex
            </summary>
            <param name="providedEventTypeIndex">index in provided event types.</param>
            <returns>Provided event type.</returns>
        </member>
        <member name="T:OpenMI.Standard.ILinkableComponent">
            <summary>
            <para>The ILinkableComponent is the key interface in the OpenMI standard.
            Any OpenMI compliant component must implement ILinkableComponent.</para>
            
            <para>OpenMI compliance definition:</para>
            
            <para>§ 1) An OpenMI compliant component must implement the ILinkableComponent interface according to specifications provided as comments in the OpenMI.Standard interface source code.</para>
            
            <para>§ 2) An OpenMI compliant component must, when compiled, reference the OpenMI.Standard.dll, which is released and compiled by the OpenMI Association.</para>
            
            <para>§ 3) An OpenMI compliant component must be associated with a XML file, which complies to (can be validated with) the LinkableComponent.xsd schema.</para>
            
            <para>§ 4) An OpenMI compliant component must be associated with a XML file, which complies to (can be validated with) the OpenMICompliancyInfo.xsd schema. This file must be submitted to the OpenMI Association.</para>
            
            <para>§ 5) The OpenMI Association provides two additional interfaces which OpenMI compliant components may or may not implement; the IManageState interface and the IDiscreteTimes interface. However, if these interfaces are implemented, each method and property must implemented according to the comments given in the OpenMI.Standard interface source code.</para>
            
            <para>§ 6) The OpenMI Association’s downloadable standard zip file provides the only recognized version of source files, xml schemas and assembly file.</para>
            </summary>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.Initialize(OpenMI.Standard.IArgument[])">
            <summary>
            <para>Initializes the LinkableComponent.</para>
            
            <para>The Initialize method will and must be invoked before any other method or property in the 
            ILinkableComponent interface is invoked.</para>
            
            <para>When the Initialize methods has been invoked the properties ModelID, ModelDescription, 
            ComponentID, ComponentDescription, InputExchangeItemCount, OutExchangeItemCount, TimeHorizon, 
            and the methods GetInputExchangeItem( ), GetOutputExchangeItem( ), AddLink( ), RemoveLink( ), 
            Validate( ), and Prepare( ) must be prepared for invocation.</para>
            
            <para>It is only required that the method Initialize can be invoked once. If the Initialize method
            is invoked more that once and the LinkableComponent cannot handle this; an exception must be
            thrown.</para>
            
            <para>REMARKS:</para>
            <para>The properties argument is typically generated based on the information given in the OMI file. 
            The arguments typically contain information about name and location of input files.</para>
            <para>The Initialize method will typically populate the component by reading input files, allocate memory, 
            and organize the input exchange items and output exchange items.</para>
            </summary>
            
            <param name="properties">
            see OpenMI.Standard.IArgument interface
            .</param>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.GetInputExchangeItem(System.Int32)">
            <summary>
            <para>Returns the InputExchangeItem corresponding to the inputExchangeItemIndex
            provided in the method arguments.</para>
            
            <para>This method must be accessible after the Initialize( ) method has been
            invoked and until the Prepare( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Prepare( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            
            <para>This method basically returns a reference to the InputExchangeItem object.
            There is no guarantee that this object is not altered by other components
            after it has been returned. It is the responsibility of the LinkableComponent
            to make sure that such possible alterations does not subsequently corrupt
            the LinkableComponent.</para>
            </summary>
            
            <param name="inputExchangeItemIndex">
            Identifies the index-number of the requested InputExchangeItem (indexing starts from zero)
            This method must accept values of inputExchangeItemIndex in the interval
            [0, InputExchangeItemCount - 1]. If the inputExchangeItemIndex is outside this
            interval an exception must be thrown.</param>
            
            <returns>
            The InputExchangeItem as identified by inputExchangeItemIndex.
            </returns>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.GetOutputExchangeItem(System.Int32)">
            <summary>
            <para>Returns the OutputExchangeItem corresponding to the outputExchangeItemIndex
            provided in the method arguments.</para>
            
            <para>This method must be accessible after the Initialize( ) method has been
            invoked and until the Prepare( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Prepare( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            
            <para>This method basically returns a reference to the OutputExchangeItem object.
            There is no guarantee that this object is not altered by other components
            after it has been returned. It is the responsibility of the LinkableComponent
            to make sure that such possible alterations does not subsequently corrupt
            the LinkableComponent.</para>
            </summary>
            
            <param name="outputExchangeItemIndex">
            Identifies the index-number of the requested OutputExchangeItem (indexing starts from zero)
            This method must accept values of outputExchangeItemIndex in the interval
            [0, OutputExchangeItemCount - 1]. If the outputExchangeItemIndex is outside this
            interval an exception must be thrown.</param>
            
            <returns>
            The OutputExchangeItem as identified by inputExchangeItemIndex.
            </returns>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.AddLink(OpenMI.Standard.ILink)">
            <summary>
            <para>Adds a Link to the LinkableComponent</para>
            
            <para>This method must be accessible after the Initialize( ) method has been
            invoked and until the Prepare( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Prepare method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            </summary>
            
            <param name="link">Link to be added.</param>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.RemoveLink(System.String)">
            <summary>
            <para>Removes a Link from the LinkableComponent</para>
            
            <para>This method must be accessible after the Initialize( ) method has been
            invoked and until the Prepare( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Prepare( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            
            <para>If the LinkID is not recognized an exception must be thrown</para> 
            </summary>
            
            <param name="linkID">LinkID for the link to be removed.</param>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.Validate">
            <summary>
            <para>Validates the populated instance of the LinkableComponent</para>
            
            <para>This method must be accessible after the Initialize( ) method has been
            invoked and until the Finish( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Finish( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para> 
            </summary>
            
            <returns>
            Returns an empty string if the component is valid otherwise returns a message
            </returns>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.Prepare">
            <summary>
            <para>Prepare for GetValues invocation</para>
            
            <para>This method must be accessible after the Initialize( ) method has been
            invoked and until the Finish( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Finish( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            
            <para>It is only required that the Prepare( ) method can be invoked once. If the Prepare method
            is invoked more that once and the LinkableComponent cannot handle this an exception must be thrown.</para>
            </summary>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.GetValues(OpenMI.Standard.ITime,System.String)">
             <summary>
             <para>Returns a ValuesSet, which is either a ScalarSet or a VectorSet, where the values applies
             to the time (TimeStamp or TimeSpan) defined in the method arguments and corresponds to the
             previously added Link, which is identified by the LinkID provided in the method arguments.</para>
             
             <para>The number of Scalars or Vectors must match the number of elements in the target ElementSet
             as defined in Link.TargetElementSet.ElementCount</para>
             
             <para>The GetValues method must accept requests for data for any previously added link. 
             If the LinkID is not recognized an exception must be thrown.</para>
             
             <para>If the Unit conversion factor and/or the Unit offset of the provided quantity does
             not match the Unit conversion factor and/or the Unit offset of the accepting quantity,
             unit conversion must be performed so the provided values corresponds to the unit of the
             accepting quantity.</para>
             
             <para>If the accepting ElementSet is geo-referenced the provided values must be converted to
             apply to the geometry of the elements in the accepting ElementSet.</para>
            
             <para>If the LinkableComponent at the time when the GetValues method is invoked has invoked
             the GetValues method on the invoking LinkableComponet and this component has not yet return
             the values, the LinkableComponent may not re-invoke the GetValues method again on that component
             until it has returned the values.</para>
             
             <para>The GetValues method is not required to return values for times outside the TimeHorizon of the
             LinkableComponent. If the GetValues method is invoked with a time argument that is outside the
             TimeHorizon of the LinkableComponent and the LinkableComponent cannot handle such invocation
             an exception must be thrown.</para>
             
             <para>The GetValues method is not required to return values before the time defined by the EarliestInputTime
             property of the accepting component. If the GetValues method is invoked with a time argument that is
             before this time and the LinkableComponent cannot handle this an exception must be thrown</para>
             
             <para>The LinkableComponent must send the SourceAfterGetValuesCall event immediately after the GetValues
             method is invoked. The LinkableComponent must send the SourceBeforeGetValuesReturn event immediately
             preceding it returns the values. If the LinkableComponent invokes GetValues in an other
             LinkableComponent it must send the TargetBeforeGetValuesCall event immediately preceding the
             GetValues invocation and the TargetAfterGetValuesReturn event immediately after the invoked
             LinkableComponent has retuned the values. If the LinkableComponent is progressing time steps
             or changing state the TimeStepProgress event and/or the DataChange event, respectively must
             be send.</para>
             
             <para>The GetValues method must be accessible after the Prepare( ) method has been
             invoked and until the Finish( ) method has been invoked. If this Method
             is accessed before the Prepare( ) method has been invoked or after the
             Finish( ) method has been invoked and the LinkableComponent cannot handle
             this an exception must be thrown.</para>
             
             <para>This method basically returns a reference to the ValueSet object.
             There is no guarantee that this object is not altered by other components
             after it has been returned. It is the responsibility of the LinkableComponent
             to make sure that such possible alterations does not subsequently corrupt
             the LinkableComponent.</para>
             </summary>
             
             <param name="time">
             The time for which the values are requested.</param>
             
             <param name="linkID">
             ID for the previously added link object.</param>
             
             <returns>
             ValueSet corresponding the the time and LinkID argument (ScalarSet or VectorSet)
             </returns>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.Finish">
            <summary>
            <para>This method is and must be invoked as the second last of any methods in the
            ILinkableComponent interface.</para>
            
            <para>This method must be accessible after the Initialize() method has been invoked 
            and before the Dispose() method has been invoked. If this method is invoked before 
            the Initialize() method has been invoked or after the Dispose() method has 
            been invoked and the LinkableComponent cannot handled this an exception must be thrown.</para>
            </summary>
        </member>
        <member name="M:OpenMI.Standard.ILinkableComponent.Dispose">
            <summary>
            <para>This method is and must be invoked as the last of any methods in the ILinkableComponent interface.</para>
            
            <para>This method must be accessible after the Finish() method has been invoked. 
            If this method is invoked before the Finish() method has been invoked and the 
            LinkableComponent cannot handled this an exception must be thrown.</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILinkableComponent.ComponentID">
            <summary>
            <para>Identifies the specific ILinkableComponent implementation (the class not the instance/object)</para>
            
            <para>This property must be accessible after the Initialize( ) method has been
            invoked and until the Finish( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Finish( ) method has been invoked and the LinkableComponent cannot handle
            this and exception must be thrown.</para>
            
            <para>EXAMPLE:</para>
            <para>"MODFLOW", "Mike 11", "Hydroworks RS", "Sobek", "HEC RAS"</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILinkableComponent.ComponentDescription">
            <summary>
            <para>Describes the ILinkableComponent implementation (the class not the instance/object)</para>
            
            <para>This property must be accessible after the Initialize( ) method has been
            invoked and until the Finish( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Finish( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            
            <para>EXAMPLE:</para>
            <para>"MODFLOW Ground water model", "Mike 11 riveer model", "Hydroworks RS river model", "Sobek river model"</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILinkableComponent.ModelID">
            <summary>
            <para>Identifies the instance of the LinkableComponent (the instantiated and populated object)</para>
            
            <para>This property must be accessible after the Initialize( ) method has been
            invoked and until the Finish( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Finish( ) method has been invoked and the LinkableComponent cannot handle
            this and exception must be thrown.</para>
            
            <para>EXAMPLE:</para>
            <para>"The Rhine river model", "Catchment 23A"</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILinkableComponent.ModelDescription">
            <summary>
            <para>Describes the instance of the LinkableComponent (the instantiated and populated object)</para>
            
            <para>This property must be accessible after the Initialize( ) method has been
            invoked and until the Finish( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Finish( ) method has been invoked and the LinkableComponent cannot handle
            this and exception must be thrown.</para>
            
            <para>EXAMPLE:</para>
            <para>"The Rhine river model hydrodynamic model, wet season scenario"</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILinkableComponent.InputExchangeItemCount">
            <summary>
            <para>Defines the number of input exchange items that can be retrieves
            with the GetInputExchangeItem( ) method.</para>
            
            <para>This property must be accessible after the Initialize( ) method has been
            invoked and until the Prepare( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Prepare( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILinkableComponent.OutputExchangeItemCount">
            <summary>
            <para>Defines the number of output exchange items that can be retrieves
            from the GetOutputExchangeItem( ) method.</para>
            
            <para>This property must be accessible after the Initialize( ) method has been
            invoked and until the Prepare( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Prepare( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILinkableComponent.TimeHorizon">
            <summary>
            <para>Defines the time span within which the LinkableComponent can return values without 
            using temporal extrapolation. For numerical models this is typically the time horizon 
            of the available input data. If the LinkableComponent does not know time at all or of 
            the LinkableComponent can provide data at any time null should be returned.</para>
            
            <para>Note that the GetValues( ) method may be invoked with time arguments that outside the time 
            horizon defined in this method. In this case the linkable component may return extrapolated 
            values or throw an exception if the sound values cannot be generated by means of extrapolation.</para>
            
            <para>This property must be accessible after the Initialize( ) method has been
            invoked and until the Prepare( ) method has been invoked. If this property
            is accessed before the Initialize( ) method has been invoked or after the
            Prepare( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILinkableComponent.EarliestInputTime">
            <summary>
            <para>The earliestInputTime property defines earliest time for which the LinkableComponent 
            will invoke the GetValues on other LinkableComponent. The LinkableComponent must 
            ensure that earliestInputTime property always reflects the latest possible time. 
            When the earliestInputTime property is updated the updated time must always be 
            later than any previous times exposed by this property</para>
            
            <para>This property must be accessible after the Prepare( ) method has been
            invoked and until the Finish( ) method has been invoked. If this property
            is accessed before the Prepare( ) method has been invoked or after the
            Finish( ) method has been invoked and the LinkableComponent cannot handle
            this an exception must be thrown.</para>
            
            <para>REMARKS:</para>
            <para>Most time stepping numerical models keeps typically only the calculated values corresponding 
            to the current time step and the previous time step in memery. In order to enable the 
            LinkableComponent to return values before that an internal buffer is typically established 
            for each link added to this component. The earliestInputTime property on the LinkableComponent 
            to which such component is linked is typically used to detect which time related data that 
            can be removed from these buffers.</para>
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IDataOperation">
            <summary>
            DataOperation interface
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IDataOperation.Initialize(OpenMI.Standard.IArgument[])">
            <summary>
            This method should not be a part of the standard since it is not required 
            to be invoked by any outside component. However, in order to avoid changing 
            the standard it will remain in the IDataOperation interface. 
            It is recommended simply to make an empty implementation of this method.
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IDataOperation.GetArgument(System.Int32)">
            <summary>
            <para>Gets the argument object (instance of class implementing IArgument) as
            identified by the argumentIndex parameter.</para>
            </summary>
            
            <param name="argumentIndex">
            <para>The index-number of the requested DataOperation(indexing starts from zero)</para>
            <para>This method must accept values of argumentIndex in the interval [0, ArgumentCount - 1].
            If the argumentIndex is outside this interval an exception must be thrown.</para>.</param>
            
            <returns>The Argument as identified by argumentIndex.</returns>
        </member>
        <member name="M:OpenMI.Standard.IDataOperation.IsValid(OpenMI.Standard.IInputExchangeItem,OpenMI.Standard.IOutputExchangeItem,OpenMI.Standard.IDataOperation[])">
            <summary>
            Validates a specific combination of InputExchangeItem, OutputExchangeItem and a 
            selection of DataOperations. If this combination is valid true should be 
            returned otherwise false should be returned.
            </summary>
            
            <param name="inputExchangeItem">The input exchange item.</param>
            
            <param name="outputExchangeItem">The output exchange item.</param>
            
            <param name="selectedDataOperations">The already selected data operations.</param>
            
            <returns>True if the combination of InputExchangeItem, OutputExchangeItem, and the array 
            of dataOperations provided in the methods argument is valid, otherwise false.</returns>
        </member>
        <member name="P:OpenMI.Standard.IDataOperation.ID">
            <summary>
            <para>Identification string for the data operation.</para>
            
            <para>Two or more data operations provided by one OutputExchangeItem may not have the same ID.</para> 
            
            <para>EXAMPLE:</para>
            <para>"Mean value", "Max value", "Spatially averaged", "Accumulated", "linear conversion"</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IDataOperation.ArgumentCount">
            <summary>
            Number of arguments for this data operation
            </summary>
        </member>
        <member name="T:OpenMI.Standard.ISpatialReference">
            <summary>
            SpatialReference interface
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ISpatialReference.ID">
            <summary>
            Identifier indicating which spatial reference to use
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IOutputExchangeItem">
            <summary>
            <para>An IOutputExchangeItem describes an output item that can be delivered by a LinkableComponent.
            The item describes on which elementset a quantity can be provided.</para>
            <para>An output exchange item may provide data operations (interpolation in time, spatial interpolation etc.) that can
            be performed on the output exchange item before the values are delivered to the target ILinkableComponent</para>
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IOutputExchangeItem.GetDataOperation(System.Int32)">
            <summary>
            Get one of the data operations that can be performed on the output quantity/elemenset.
            </summary>
            <param name="dataOperationIndex">The index for the data operation [0, DataOperationCount-1].</param>
            <returns>The data operation for index dataOperationIndex.</returns>
        </member>
        <member name="P:OpenMI.Standard.IOutputExchangeItem.DataOperationCount">
            <summary>
            The number of data operations that can be performed on the output quantity/elemenset.
            </summary>
        </member>
        <member name="T:OpenMI.Standard.ILink">
            <summary>
            Link interface
            </summary>
        </member>
        <member name="M:OpenMI.Standard.ILink.GetDataOperation(System.Int32)">
            <summary>
            Get the data operation with index DataOperationIndex.
            If this method is invoked with a dataOperationIndex, which is outside the interval
            [0,DataOperationCount] an exception must be thrown.
            </summary>
             <returns>DataOperation according to the argument: dataOperationCount.</returns>
        </member>
        <member name="P:OpenMI.Standard.ILink.ID">
            <summary>
            Identification string
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILink.Description">
            <summary>
            Additional descriptive information
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILink.DataOperationsCount">
            <summary>
            Number of data operations
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILink.TargetQuantity">
            <summary>
            Target quantity
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILink.TargetElementSet">
            <summary>
            Target elementset
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILink.SourceElementSet">
            <summary>
            Source elementset
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILink.SourceComponent">
            <summary>
            Souce linkable component
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILink.SourceQuantity">
            <summary>
            Source quantity
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ILink.TargetComponent">
            <summary>
            Target linkable component
            </summary>
        </member>
        <member name="T:OpenMI.Standard.ITimeStamp">
            <summary>
            TimeStamp interface
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ITimeStamp.ModifiedJulianDay">
            <summary>
            Get TimeStamp expressed as ModifiedJulianDateAndTime (JulianDateAndTime - 2400000.5)
            Number of days since 1858/11/17 12:00:00.00, and fraction of 24hr.
            See for example http://aa.usno.navy.mil/data/docs/JulianDate.html
            </summary>
        </member>
        <member name="T:OpenMI.Standard.ElementType">
            <summary>
            Shape Type of an Elementset
            </summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.IDBased">
            <summary>
            Identifier based</summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYPoint">
            <summary>
            Points</summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYLine">
            <summary>
            Lines</summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYPolyLine">
            <summary>
            Polylines</summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYPolygon">
            <summary>
            Polygons</summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYZPoint">
            <summary>
            3D Point
            </summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYZLine">
            <summary>
            3D Line
            </summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYZPolyLine">
            <summary>
            3D Polyline
            </summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYZPolygon">
            <summary>
            3D Polygon
            </summary>
        </member>
        <member name="F:OpenMI.Standard.ElementType.XYZPolyhedron">
            <summary>
            3D Polyhedron
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IElementSet">
            <summary>
            <para>Data exchange between components in OpenMI is always related to one or more elements in a space,
            either geo-referenced or not. An element set in OpenMI can be anything from a one-dimensional array
            of points, line segments, poly lines or polygons, through to an array of three-dimensional volumes.
            As a special case, a cloud of IDBased elements (without co-ordinates) is also supported thus allowing
            exchange of arbitrary data that is not related to space in any way.</para>
            
            <para>The IElementSet interface has been defined to describe, in a finite element sense, the space where
            the values apply, while preserving a course granularity level of the interface.</para>
            
            <para>Conceptually, IElementSet is composed of an ordered list of elements having a common type.
            The geometry of each element can be described by an ordered list of vertices. The shape of
            three-dimensional elements (i.e. volumes or polyhedrons) can be queried by face. If the element set
            is geo-referenced (i.e. the SpatialReference is not Null), co-ordinates (X,Y,Z) can be obtained for
            each vertex of an element. The ElementType is an enumeration, listed in Table 1. Data not related
            to spatial representation can be described by composing an element set containing one (or more)
            IDBased elements, without any geo-reference.</para>
            
            <para>Note that IElementSet can be used to query the geometric description of a model schematization,
            but an implementation does not necessarily provide all topological knowledge on inter-element
            connections.</para>
            
            <para>The interface of a spatial reference (ISpatialReference) only contains a string ID. No other
            properties and methods have been defined, as the OpenGIS SpatialReferenceSystem
            specification (OGC 2002) provides an excellent standard for this purpose.</para>
            
            <para>The element set and the element are identified by a string ID. The ID is intended to be useful
            in terms of an end user. This is particularly useful for configuration as well as for providing
            specific logging information. However, the properties of an element (its vertices and/or faces)
            are obtained using an integer index (elementIndex, faceIndex and vertexIndex). This functionality
            is introduced because an element set is basically an ordered list of elements, an element may have
            faces and an element (or a face) is an ordered list of vertices. The integer index indicates the
            location of the element/vertex in the array list.</para>
            
            <para>While most models encapsulate static element sets, some advanced models might contain dynamic
            elements (e.g. waves). A version number has been introduced to enable tracking of changes over
            time. If the version changes, the element set might need to be queried again during the computation
            process.</para>
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IElementSet.GetElementIndex(System.String)">
            <summary>
            Index of element 'ElementID' in the elementset. Indexes start from zero.
            There are not restrictions to how elements are ordered.
            </summary>
            <param name="elementID">
            Identification string for the element for which the element index is requested.
            If no element in the ElementSet has the specified elementID, an exception must be thrown.
            .</param>
        </member>
        <member name="M:OpenMI.Standard.IElementSet.GetElementID(System.Int32)">
            <summary>
            Returns ID of 'ElementIndex'-th element in the ElementSet. Indexes start from zero.
            </summary>
            <param name="elementIndex">
            The element index for which the element ID is requested. If the element index is outside
            the range [0, number of elements -1], and exception must be thrown.
            .</param>
        </member>
        <member name="M:OpenMI.Standard.IElementSet.GetVertexCount(System.Int32)">
            <summary>
            <para>Number of vertices for the element specified by the elementIndex.</para>
            
            <para>If the GetVertexCount()method is invoked for ElementSets of type ElementType.IDBased, an exception
            must be thrown.</para>
            </summary>
            
            <param name="elementIndex">
            <para>The element index for the element for which the number of vertices is requested.</para>
            
            <para>If the element index is outside the range [0, number of elements -1], and exception
            must be thrown.</para>
            .</param>
            <returns>Number of vertices in element defined by the elementIndex.</returns>
        </member>
        <member name="M:OpenMI.Standard.IElementSet.GetFaceCount(System.Int32)">
            <summary>
            Returns the number of faces in an element.
            </summary>
            <param name="elementIndex">
            <para>Index for the element</para>
            
            <para>If the element index is outside the range [0, number of elements -1], and exception
            must be thrown.</para>
            .</param>
            <returns>Number of faces.</returns>
        </member>
        <member name="M:OpenMI.Standard.IElementSet.GetFaceVertexIndices(System.Int32,System.Int32)">
            <summary>
            Gives an array with the vertex indices for a face.
            </summary>
            <param name="elementIndex">Element index.</param>
            <param name="faceIndex">Face index.</param>
            <returns>The vertex indices for this face.</returns>
        </member>
        <member name="M:OpenMI.Standard.IElementSet.GetXCoordinate(System.Int32,System.Int32)">
            <summary>
            <para>X-coord for the vertex with VertexIndex of the element with ElementIndex</para>
            </summary>
            <param name="elementIndex">element index.</param>
            <param name="vertexIndex">vertex index in the element with index ElementIndex.</param>
        </member>
        <member name="M:OpenMI.Standard.IElementSet.GetYCoordinate(System.Int32,System.Int32)">
            <summary>
            Y-coord for the vertex with VertexIndex of the element with ElementIndex. 
            </summary>
            <param name="elementIndex">element index.</param>
            <param name="vertexIndex">vertex index in the element with index ElementIndex.</param>
        </member>
        <member name="M:OpenMI.Standard.IElementSet.GetZCoordinate(System.Int32,System.Int32)">
            <summary>
            Z-coord for the vertex with VertexIndex of the element with ElementIndex.
            </summary>
            <param name="elementIndex">element index.</param>
            <param name="vertexIndex">vertex index in the element with index ElementIndex.</param>
        </member>
        <member name="P:OpenMI.Standard.IElementSet.ID">
            <summary>
            <para>Identification string</para>
            
            <para>EXAMPLE:</para>
            <para>"River Branch 34", "Node 34"</para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IElementSet.Description">
            <summary>
            Additional descriptive information
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IElementSet.SpatialReference">
            <summary>
            <para>The SpatialReference defines the spatial reference to be used in association with
            the coordinates in the ElementSet. For all ElementSet Types except ElementType.IDBased
            a spatial reference must be defined. For ElementSets of type ElementType.IDBased the
            SpatialReference property may be null.</para>
            
            <para>EXAMPLE:</para>
            <para>SpatialReference.ID = "WG84" or "Local coordinate system"</para>
            <para></para>
            <para></para>
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IElementSet.ElementType">
            <summary>
            ElementType of the elementset. 
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IElementSet.ElementCount">
            <summary>
            Number of elements in the ElementSet
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IElementSet.Version">
            <summary>
            The current version number for the populated ElementSet.
            The version must be incremented if anything inside the ElementSet is changed.
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IDiscreteTimes">
            <summary>
            <para>Within and outside modelling exercises, many situations occur where ‘raw’ data is desired at
            the (discrete) time stamp as it is available in the source component. A typical example is
            the comparison of computation results with monitoring data, or a computational core that wants
            to adhere to the time stepping of its data source. To keep the values fixed to the discrete
            times as they are available in the source component, the IDiscreteTimes interface has been
            defined. This interface can provide a list of time stamps for which values of a quantity on
            an element set are available.</para>
            
            <para>Note that the IDiscreteTimes interface is an optional interface to provide more detailed
            information on the temporal discretization of available data. It is not required to implement
            the IDiscreteTimes interface in order to claim OpenMI compliance for a Component. However, if
            the IDiscreteTimes interface is implemented it must be implemented according to the definitions
            given below.</para>
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IDiscreteTimes.HasDiscreteTimes(OpenMI.Standard.IQuantity,OpenMI.Standard.IElementSet)">
            <summary>
            Returns true if the component can provide discrete times for the specific exchange
            item defined by the arguments quantity and elementSet 
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IDiscreteTimes.GetDiscreteTimesCount(OpenMI.Standard.IQuantity,OpenMI.Standard.IElementSet)">
            <summary>
            Returns the number of discrete time steps for a specific combination of ElementSet and Quantity
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IDiscreteTimes.GetDiscreteTime(OpenMI.Standard.IQuantity,OpenMI.Standard.IElementSet,System.Int32)">
            <summary>
            Get n-th discrete time stamp or time span for a specific combination of ElementSet and Quantity.
            This method must accept values of discreteTimeIndex in the interval [0, GetDiscreteTimesCount - 1].  
            If the discreteTimeIndex is outside this interval an exception must be thrown.
            </summary>
            <param name="quantity">The quantity.</param>
            <param name="elementSet">The element.</param>
            <param name="discreteTimeIndex">index of timeStep.</param>
            <returns>Discrete time stamp or time span.</returns>
        </member>
        <member name="T:OpenMI.Standard.ITimeSpan">
            <summary>
            TimeSpan interface
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ITimeSpan.Start">
            <summary>
            Time span's begin time stamp
            </summary>
        </member>
        <member name="P:OpenMI.Standard.ITimeSpan.End">
            <summary>
            Time span's end time stamp
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IUnit">
            <summary>
            Unit interface
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IUnit.ID">
            <summary>
            Identification string
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IUnit.Description">
            <summary>
            Additional descriptive information
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IUnit.ConversionFactorToSI">
            <summary>
            Conversion factor to SI ('A' in: SI-value = A * quant-value + B)
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IUnit.OffSetToSI">
            <summary>
            OffSet to SI ('B' in: SI-value = A * quant-value + B)
            </summary>
        </member>
        <member name="T:OpenMI.Standard.ValueType">
            <summary>
            Value(Set)Type for Quantity
            </summary>
        </member>
        <member name="F:OpenMI.Standard.ValueType.Scalar">
            <summary>
            Scalar</summary>
        </member>
        <member name="F:OpenMI.Standard.ValueType.Vector">
            <summary>
            Vector </summary>
        </member>
        <member name="T:OpenMI.Standard.IQuantity">
            <summary>
            Quantity interface
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IQuantity.ID">
            <summary>
            Identifier
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IQuantity.Description">
            <summary>
            Additional descriptive information
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IQuantity.ValueType">
            <summary>
            Quantity's value type (vector, scalar or ...)
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IQuantity.Dimension">
            <summary>
            Quantity's Dimension
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IQuantity.Unit">
            <summary>
            Unit
            </summary>
        </member>
        <member name="T:OpenMI.Standard.EventType">
            <summary>
            Enumeration for event types
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.Warning">
            <summary>
            Warning.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.Informative">
            <summary>
            Informative. Any type of information.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.ValueOutOfRange">
            <summary>
            Value out of range. If a LinkableComponent receives values through the GetValues method, 
            which are detected by the receiving component as out-of-range an OutOfRange event must 
            be send. Alternatively, if the component cannot proceed with the received value or if 
            proceeding with the received value will make the component unstable or make the component 
            generate erroneous results and exception can be thrown.  
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.GlobalProgress">
            <summary>
            Global progress. Indicates progress as percentage of global time horizon. It 
            is not mandatory for LinkableComponent to provide this event type. 
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.TimeStepProgres">
            <summary>
            Timestep progress. Indicates progress as % for the current time step. 
            It is not mandatory for LinkableComponent to provide this event type. 
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.DataChanged">
            <summary>
            Data changed. Events of this event type must be send at least once 
            during each period when the LinkableComponent hold the thread if the internal 
            state of the component has changed.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.TargetBeforeGetValuesCall">
            <summary>
            Target before GetValues call. Immediately before a LinkableComponent invokes 
            the GetValues method in another LinkableComponent an event of type 
            TargetBeforeGetValuesCall must be send. 
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.SourceAfterGetValuesCall">
            <summary>
            Source after GetValues call. Immediately when the GetValues method is invoked in 
            a LinkableComponent this component must send an event of type SourceAfterGetValuesCall  
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.SourceBeforeGetValuesReturn">
            <summary>
            Source before GetValues return. Immediately before a LinkableComponent in which the GetValues 
            method has been invoked returns the thread to the calling component an event of type 
            SourceBeforeGetValuesReturn must be send.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.TargetAfterGetValuesReturn">
            <summary>
            Target after GetValues return. Immediately after a LinkableComponent which has 
            invoked the GetValues method in another LinkableComponent receives the thread back from 
            this component (after this component returns the values) an event of type 
            TargetAfterGetValuesReturn must be send. 
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.Other">
            <summary>
            Other. Any other event that is found useful to implement. 
            </summary>
        </member>
        <member name="F:OpenMI.Standard.EventType.NUM_OF_EVENT_TYPES">
            <summary>
            Number of event types
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IEvent">
             <summary>
             <para>Within modern software systems, events are often applied for all types of messaging. Within
             OpenMI a lightweight event mechanism is applied, using a generic Event interface and an enumeration
             of event types (OpenMI.Standard.EventType) to allow the implementation of generic tools that
             perform monitoring tasks such as logging, tracing, or online visualization. Linkable components
             must generate events to which other linkable components or tools can subscribe. In this way, it 
             becomes possible to implement these generic tools without requiring any knowledge of the specific 
             tools in the components themselves. By adopting the OpenMI event types, system developers can use 
             those tools without additional effort. Note that the event mechanism should not be used to pass 
             data sets. Data sets should be retrieved through the GetValues() call.</para>
            
             <para>The event mechanism is also used to facilitate pausing and resuming of the computation 
             thread, as the computation process of an entire model chain is rather autonomous and not 
             controlled by any master controller. Once a component receives the thread, it must send an 
             event, so listeners (e.g. a GUI) can grab and hold the thread, and thus pause the computation 
             by not returning control. In normal conditions, the control is returned so the component can 
             continue its computation. Of course the computation is also controlled at the level that 
             triggers the first component of the chain by means of a GetValues()-call. Stop firing those 
             calls will also result in a paused system, although it may take a while before an entire call 
             stack completes its processing activity.</para>
             </summary>
        </member>
        <member name="M:OpenMI.Standard.IEvent.GetAttribute(System.String)">
            <summary>
            Get the value of a Key=Value pair, containing additional information on the event.
            This method must throw an exception if the key is not recognized.  
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IEvent.Type">
            <summary>
            Type of event
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IEvent.Description">
            <summary>
            Additional descriptive information
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IEvent.Sender">
            <summary>
            Linkable component that generated the event
            </summary>
        </member>
        <member name="P:OpenMI.Standard.IEvent.SimulationTime">
            <summary>
            Current SimulationTime
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IListener">
            <summary>
            Listener interface
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IListener.OnEvent(OpenMI.Standard.IEvent)">
            <summary>
            Method called when event is raised
            </summary>
            <param name="anEvent">Event that has been raised.</param>
        </member>
        <member name="M:OpenMI.Standard.IListener.GetAcceptedEventTypeCount">
            <summary>
            Get number of accepted event types
            </summary>
            <returns>Number of accepted event types.</returns>
        </member>
        <member name="M:OpenMI.Standard.IListener.GetAcceptedEventType(System.Int32)">
            <summary>
            <para>Get accepted event type with index acceptedEventTypeIndex.</para>
            
            <para>If this method is invoked with an argument that is outside the interval
            [0, numberOfAcceptedEventsTypes], where numberOfAcceptedEventsTypes is
            the values obtained through the method GetAcceptedEventTypeCount(),
            an exception must be thrown.</para> 
            </summary>
            <param name="acceptedEventTypeIndex">index in accepted event types.</param>
            <returns>Accepted event type.</returns>
        </member>
        <member name="T:OpenMI.Standard.DimensionBase">
            <summary>
            Enumeration for base dimensions
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.Length">
            <summary>
            Base dimension length.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.Mass">
            <summary>
            Base dimension mass.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.Time">
            <summary>
            Base dimension time.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.ElectricCurrent">
            <summary>
            Base dimension electric current.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.Temperature">
            <summary>
            Base dimension temperature.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.AmountOfSubstance">
            <summary>
            Base dimension amount of substance.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.LuminousIntensity">
            <summary>
            Base dimension luminous intensity.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.Currency">
            <summary>
            Base dimension currency.
            </summary>
        </member>
        <member name="F:OpenMI.Standard.DimensionBase.NUM_BASE_DIMENSIONS">
            <summary>
            Total number of base dimensions.
            </summary>
        </member>
        <member name="T:OpenMI.Standard.IDimension">
            <summary>
            Dimension interface
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IDimension.GetPower(OpenMI.Standard.DimensionBase)">
            <summary>
            <para>Returns the power for the requested dimension</para>
            
            <para>EXAMPLE:</para>
            <para>For a quantity such as flow, which may have the unit m3/s, the GetPower method must
            work as follows:</para>
            
            <para>myDimension.GetPower(DimensionBase.AmountOfSubstance) -->returns 0</para>
            <para>myDimension.GetPower(DimensionBase.Currency) --> returns 0</para>
            <para>myDimension.GetPower(DimensionBase.ElectricCurrent) --> returns 0</para>
            <para>myDimension.GetPower(DimensionBase.Length) --> returns 3</para>
            <para>myDimension.GetPower(DimensionBase.LuminousIntensity) --> returns 0</para>
            <para>myDimension.GetPower(DimensionBase.Mass) --> returns 0</para>
            <para>myDimension.GetPower(DimensionBase.Temperature) --> returns 0</para>
            <para>myDimension.GetPower(DimensionBase.Time) --> returns -1</para>
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IDimension.Equals(OpenMI.Standard.IDimension)">
            <summary>
            Check if a Dimension instance equals to another Dimension instance.
            </summary>
            <param name="otherDimension">Dimension instance to compare with.</param>
            <returns>True if the dimensions are equal.</returns>
        </member>
        <member name="T:OpenMI.Standard.IScalarSet">
            <summary>
            ScalarSet interface
            (Array of doubles for a certain quantity on a certain elementset).
            </summary>
        </member>
        <member name="M:OpenMI.Standard.IScalarSet.GetScalar(System.Int32)">
            <summary>
            Value for one of the elements in the set
            </summary>
            <param name="elementIndex">index in the scalar set.</param>
            <returns>double scalar value.</returns>
        </member>
    </members>
</doc>
